package com.example.shutdown_v1.service;

import com.example.shutdown_v1.constants.PowerDeviceConstants;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;

import java.time.Duration;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;

/**
 * 被动电力监控服务
 * 处理从MQTT主动上报的电力状态数据
 */
@Service
@Slf4j
@RequiredArgsConstructor
public class PassivePowerMonitorService {
    
    private final RedisTemplate<String, Object> redisTemplate;
    
    /**
     * 处理电力设备主动上报的状态数据
     * @param topic MQTT主题 (例如: /mallpower/post 或 /mallpower/post/merchant123)
     * @param hexData 十六进制状态数据
     */
    public void processStatusReport(String topic, String hexData) {
        try {
            // 解析商家ID
            String merchantId = extractMerchantFromTopic(topic);
            
            log.info("[被动电力监控] 收到状态上报 - 商家:{}, 主题:{}, 数据:{}", 
                    merchantId, topic, hexData);
            
            // 解析电力状态数据
            PowerStatusData statusData = parseStatusData(hexData);
            if (statusData == null) {
                log.warn("[被动电力监控] 无法解析状态数据 - 商家:{}, 数据:{}", merchantId, hexData);
                return;
            }
            
            // 更新Redis中的状态
            updateMerchantStatus(merchantId, statusData);
            
            log.info("[被动电力监控] 状态已更新 - 商家:{}, 整体断电:{}, 各路状态:{}", 
                    merchantId, statusData.allPowerOff, statusData.channelStatus);
                    
        } catch (Exception e) {
            log.error("[被动电力监控] 处理状态上报失败 - 主题:{}, 数据:{}", topic, hexData, e);
        }
    }
    
    /**
     * 从MQTT主题中提取商家ID
     */
    private String extractMerchantFromTopic(String topic) {
        if (topic.startsWith("/mallpower/post/")) {
            String[] parts = topic.split("/");
            if (parts.length >= 3) {
                return parts[2]; // 返回商家ID部分
            }
        }
        
        // 默认返回default（兼容旧版单主题）
        return "default";
    }
    
    /**
     * 解析电力状态数据
     * 这里需要根据实际的电力设备协议来解析
     */
    private PowerStatusData parseStatusData(String hexData) {
        try {
            if (hexData == null || hexData.trim().isEmpty()) {
                return null;
            }
            
            String cleanHex = hexData.replace(" ", "").toUpperCase();
            
            // 示例解析逻辑（需要根据实际设备协议调整）
            // 假设数据格式：前2字节是通道数据，每个通道1位表示开关状态
            // 例如：0x3F 表示6路全通电，0x00表示6路全断电
            
            PowerStatusData result = new PowerStatusData();
            result.rawData = cleanHex;
            result.updateTime = LocalDateTime.now();
            result.channelStatus = new HashMap<>();
            
            if (cleanHex.length() >= 2) {
                int statusByte = Integer.parseInt(cleanHex.substring(0, 2), 16);
                
                // 解析各路状态（假设低6位分别对应6路电源）
                for (int channel = 1; channel <= PowerDeviceConstants.MAX_CHANNELS; channel++) {
                    boolean hasRower = (statusByte & (1 << (channel - 1))) != 0;
                    result.channelStatus.put(channel, hasRower);
                }
                
                // 计算整体断电状态
                result.allPowerOff = result.channelStatus.values().stream()
                        .noneMatch(Boolean::booleanValue);
                        
                return result;
            }
            
            return null;
            
        } catch (Exception e) {
            log.error("[被动电力监控] 解析状态数据失败: {}", hexData, e);
            return null;
        }
    }
    
    /**
     * 更新商家电力状态到Redis
     */
    private void updateMerchantStatus(String merchantId, PowerStatusData statusData) {
        String statusKey = PowerDeviceConstants.RedisKeys.MERCHANT_STATUS_PREFIX + merchantId;
        
        Map<String, Object> redisData = new HashMap<>();
        redisData.put("allPowerOff", statusData.allPowerOff);
        redisData.put("channels", statusData.channelStatus);
        redisData.put("updateTime", statusData.updateTime.toString());
        redisData.put("channelCount", statusData.channelStatus.size());
        redisData.put("rawData", statusData.rawData);
        
        // 存储到Redis Hash
        redisTemplate.opsForHash().putAll(statusKey, redisData);
        
        // 设置过期时间（24小时）
        redisTemplate.expire(statusKey, Duration.ofHours(24));
    }
    
    /**
     * 电力状态数据类
     */
    private static class PowerStatusData {
        boolean allPowerOff;
        Map<Integer, Boolean> channelStatus;
        LocalDateTime updateTime;
        String rawData;
    }
}
